The ARIS product suite provided by the assignee of the instant invention is one of the market leading business process management tools. Customers use ARIS to document and analyze their internal processes and organization. The business models created with ARIS (currently a Java-based tool) will be later published into the organization's internal website so that the created models are available to all employees. FIG. 1 is an example model created in ARIS and, in particular, shows the Sprint phase of a Scrum project.
The models created with ARIS can be very large. Indeed, some customers have created models that are larger than 5×5 meters. These very large models generally are published to the web for availability purposes, and users may want to zoom in and out to navigate within the model. One challenge associated with bringing ARIS models into a web browser is the very large size that results in memory usage and can often lead to rendering performance problems.
The web today offers different possibilities to draw an ARIS model (or any other graphic model) into a web browser. For example, in with a bitmap-based graphic, the model can be represented as one large bitmap-based web graphic format such as PNG or JPEG. The interaction can be done with HTML and JavaScript. As shown in FIG. 2, for example, an ARIS ModelViewer may be embedded in a webpage and provide a view port. The single large bitmap-based graphic is “behind” the viewport. Navigation can be performed using HTML and/or JavaScript tools.
As another example, the model can be represented as a bitmap based graphic, but instead of using one big graphic, the model is split into several tiles. This tiled graphic technique is well known in computer graphics and generally reduces memory usage and increases rendering performance. This technique has become very popular in the computer game area, as well as for some web based applications. For example, Google Maps uses this technique. FIG. 3 demonstrates the tile-based approach for displaying a model in a view port. As shown in FIG. 3, the ARIS ModelViewer view port generates the model by re-using tiles that are sent from a central repository. However, only a few small graphics (tiles) of the model are sent to the client, with the client itself generating the larger model by re-using the small tiles.
Still another option involves using vector-based graphics. In this option, the model can be represented using a vector-based format that is available for the web (and that will be supported by the common web browser) such as, for example, SVG or VML. The Adobe Flash SWF format also is a vector-based format and could theoretically be used to draw ARIS models in the web. Vector-based images have the advantage that the graphic can be scaled indefinitely without degrading quality. FIG. 4 demonstrates a vector graphic based approach to displaying a model in a view port, where vector graphics are sent to the client and interpreted by the web browser for display in the view port.
As still another option, browser side rendering (e.g., using HTML 5 Canvas or Flash rendering) may be used to send the model data to the web browser where this data will be interpreted and the model drawn by using HTML 5 or Flash. This approach is very similar to vector-based graphic approach described above. However, most common browsers already provide a renderer for vector-based graphic formats like SVG, which interprets the SVG format and translates it into graphic commands of the web browser drawing API. FIG. 5 shows model data being fed to a renderer for ultimate display in a view port in accordance with browser-side rendering techniques. The renderer interpreters the model data and creates the model graphic by using the drawing API provided by the web browser. The resulting model is displayed in the view port.
Current solutions unfortunately are not well suited to displaying ARIS type models. For instance, current solutions have restrictions regarding memory usage and rendering performance. For example, bitmap-based graphics have the disadvantages that a large image size results in a very high memory usage. Graphic formats like PNG and JPEG allow the image data to be compressed, but the browser needs to be able to decompress it to display it into the web page, thereby requiring processing power and overhead. Another disadvantage relates to the fact that bitmap-based formats cannot be scaled without losing quality. Scaling a bitmap-based image down also results in aliasing problems such that graphic information is oftentimes lost.
By contrast, the tiled based approach is advantageous in terms of memory usage and performance. Instead of creating one large graphic representing the ARIS model, the graphic can be split in several small parts (tiles) that can be repeated. An ARIS model oftentimes contains the same symbol (e.g., as in the example in FIG. 1 above). In addition, it is possible to load only the tiles that are currently visible to the user on his screen. Unfortunately, however, this approach is disadvantageous in that it is not easy to scale the graphic (model). Thus, current solutions involve creating tiles for predefined zoom/scale levels. Otherwise, free scaling of the model typically is not possible without losing quality.
Using a vector-based graphic to illustrate an ARIS model into a web browser also has its disadvantages. For instance, the memory usage of vector formats like SVG and VML, which will be supported by the web browsers, is comparable to a bitmap-based graphic format. Although not as high, it still is often seen as unacceptable. In addition, it can often take a long time to render very large SVG and VML structures.
Although the first three approaches provide a pre-rendered graphic that is to be transferred to the web browser and displayed to the user, with HTML 5 and the introduction of the “Canvas” element, it is possible to draw graphics programmatically by using a drawing API that will be provided by the web browsers. A similar approach also is possible through Adobe Flash technology. This approach involves sending some data to the web browser that will be interpreted programmatically and rendered into the web browser by using the provided drawing API. This approach has the benefit that the size of the image transferred to the browser can be significant smaller compared to the size of the generated graphic. On the other hand, this approach has the disadvantage that the step (the business logic) of interpreting, calculating, and transferring the data into drawing commands can be very expensive.
Although a solution between browser-side rendering and vector-based graphics seems to be a good option, it may not solve performance problems for very large graphics/models.
Thus, it will be appreciated by those skilled in the art that there is a need for improved techniques associated with the display of models/graphics. For instance, it will be that efficiency could be increased for very large models/graphics, while keeping processing and memory requirements low.
One aspect of certain example embodiments relates to techniques that make it possible to very quickly render vector-based graphics in a web browser or other target platform or device. The graphics that are rendered in certain example embodiments are business model related graphics.
An aspect of certain example embodiments relates to techniques for rendering vector graphics that apply to concrete formats (such as, for example, EMF, WMF, SVG, etc.) and that are applicable to vector graphics in general.
Another aspect of certain example embodiments relates to a concrete graphics format that involves abstract vector graphics (AVG).
Another aspect of certain example embodiments relates to providing graphic images to an AVG generator, along with a renderer fragment file including static code that is independent from the generated graphic but dependent on the target platform.
Another aspect of certain example embodiments relates to an AVG generator that produces program logic that is executable on the target device to cause the display of the graphic based on the program logic.
Still another aspect of certain example embodiments relates to receiving a business model created using a business process management (BPM) package and creating an AVG file based on the created business model, with the AVG file being made available for display on an external device (e.g., through a network).
Still another aspect of certain example embodiments relates to optimizing or improving the performance associated with the display of the AVG by using features present in, or made available by resort to, programming language. For instance, certain example embodiments may optimize or improve performance associated with the display of the AVG by using global constants, defining auxiliary functions and/or relying on inheritance, performing inlining, splitting constant and variable code parts, skipping commands outside of a view port or viewing area, and/or the like.
Still another aspect of certain example embodiments relates to commands, syntax, and/or semantics associated with illustrative AVG file formats.
In certain example embodiments, a method of generating an AVG file for subsequent display via a software application (e.g., a browser) on a remote device is provided. The AVG file corresponds to a graphical business process model generated in a business process management (BPM) software package. Information pertaining to the model is received. The AVG file is generated, via at least one processor, based on (a) the received information pertaining to the model, and (b) a renderer fragment file that includes code that is dependent on a platform of the remote device on which the model is to be displayed but independent from the received information pertaining to the model. The AVG file includes executable instructions for causing the model to be displayed in the software application.
In certain example embodiments, a method of displaying a graphical model on a remote device is provided. An AVG file is received on the remote device, with the AVG file having been generated based on (a) information pertaining to the model, and (b) static code that is dependent on a platform of the remote device on which the model is to be displayed but independent from the received information pertaining to the model. The AVG file includes executable instructions for causing the model to be displayed on the remote device, with the instructions including vector-based commands associated with the re-creation of the model for display on the remote device, and with each said vector-based command having a predetermined format. The instructions are executed on the remote device so as to cause the model, or a portion thereof, to be re-created within a viewable area of a display provided thereto.
In certain example embodiments, an AVG generator is provided. A receiver is configured to receive information pertaining to a graphical business process model generated in a business process management (BPM) software package. At least one processor is configured to generate an AVG file based on (a) the information pertaining to the model received by the receiver, and (b) a renderer fragment file that includes code that is dependent on a platform of a remote device on which the model is to be displayed but independent from the received information pertaining to the model. The at least one processor is further configured to structure the AVG file as vector-based instructions so that the AVG file is executable on the remote device.
According to certain example embodiments, systems comprising an AVG generator and/or an AVG renderer may be provided. Such systems optionally may include, for example, a BPM software package.
According to certain other example embodiments, BPM systems may be provided, with such systems optionally including one or more of an AVG renderer, an optionally distributable AVG renderer, etc.
For instance, in certain example embodiments, a BPM system is provided, which includes a software tool configured to generate a graphical business process model, and with the graphical business process model being representable as an XML file. An AVG generator of the system comprises a receiver configured to receive the XML file corresponding to the generated graphical business process model; and at least one processor configured to generate an AVG file based on the XML file and code that is dependent on a platform of a remote device on which the model is to be displayed but independent from the received information pertaining to the model. The at least one processor is further configured to structure the AVG file as vector-based instructions so that the AVG file is executable on the remote device. A distributable, platform specific AVG renderer configured to receive AVG files and cause received AVG files, or portions thereof, to be displayed on a device hosting the AVG renderer, also may be provided.
In certain example embodiments, a method of generating an Abstract Vector Graphics (AVG) file is provided. Input corresponding to one or more graphical elements in an image is received. The input is processed, via at least one processor, to generate a set of commands that, when executed, cause the image or a portion thereof to be displayed on a display device. The set of commands is stored in an executable file on a non-transitory computer readable storage medium for subsequent execution on the display device. The commands are selected from a list of drawing commands including at least the following members: a set transform command that defines an affine transformation matrix and changes a transform member of a state associated with the display device, an add transform command that concatenates a parameter of the add transform command with the current transform member of the state, a set clip command that defines an area in which drawing commands have an effect and changes a clip member of the state, an add clip command that concatenates a parameter of the add clip command with the current clip member of the state, a draw image command that draws an encoded image on the display device, a set shape command that sets a shape member of the state, a set font command that changes a font member of the state, a set brush command that changes a brush member of the state, a set pen command that changes a pen member of the state, a set alpha command that changes an alpha member of the state, a fill command that draws a filled shaped on the display device using the shape and brush members of the state, a draw command that draws an outline of a shape on the display device using the shape and pen members of the state, a draw text command that draws a string at a specified location on the display device using the font member of the state, a save state command that makes a copy of the complete state and pushes it onto a state stack, and a restore state command that pops a topmost entry from the state stack and sets the current state to the popped topmost entry.
In certain example embodiments, a method of displaying on a display device an image or portion thereof stored in an Abstract Vector Graphics (AVG) file is provided. The AVG file is received. Commands stored in the AVG file are executed via at least one processor so as to display the image or portion thereof. The commands include at least the following drawing commands: a set transform command that defines an affine transformation matrix and changes a transform member of a state associated with the display device, an add transform command that concatenates a parameter of the add transform command with the current transform member of the state, a set clip command that defines an area in which drawing commands have an effect and changes a clip member of the state, an add clip command that concatenates a parameter of the add clip command with the current clip member of the state, a draw image command that draws an encoded image on the display device, a set shape command that sets a shape member of the state, a set font command that changes a font member of the state, a set brush command that changes a brush member of the state, a set pen command that changes a pen member of the state, a set alpha command that changes an alpha member of the state, a fill command that draws a filled shaped on the display device using the shape and brush members of the state, a draw command that draws an outline of a shape on the display device using the shape and pen members of the state, a draw text command that draws a string at a specified location on the display device using the font member of the state, a save state command that makes a copy of the complete state and pushes it onto a state stack, and a restore state command that pops a topmost entry from the state stack and sets the current state to the popped topmost entry.
Non-transitory computer readable storage mediums tangibly storing instructions for performing the above-summarized and/or other methods also are provided by certain example embodiments.
These aspects and example embodiments may be used separately and/or applied in various combinations to achieve yet further embodiments of this invention.